package org.jeecg.modules.fund.service.impl;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.text.replacer.StrReplacer;
import cn.hutool.core.thread.ExecutorBuilder;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.Value;
import lombok.extern.slf4j.Slf4j;
import org.apache.tomcat.jni.Library;
import org.checkerframework.checker.units.qual.A;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.fund.entity.*;
import org.jeecg.modules.fund.mapper.FundLibraryMapper;
import org.jeecg.modules.fund.mapper.FundValueMapper;
import org.jeecg.modules.fund.model.FundValTotalModel;
import org.jeecg.modules.fund.service.IFundLibraryService;
import org.jeecg.modules.fund.service.IFundValueService;
import org.jeecg.modules.fund.util.FundDataUtil;
import org.jeecg.modules.fund.util.TonghsDataUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
public class FundValueServiceImpl extends ServiceImpl<FundValueMapper, FundValue> implements IFundValueService {
    @Autowired
    private IFundLibraryService fundLibraryService;
    @Autowired
    private FundLibraryMapper fundLibraryMapper;
    // 表前缀
    public static final String TABLE_NAME_PREFIX = "fund_value_";
    // ID前缀
    public static final String ID_PREFIX = "fund-";

    @Override
    public Result<String> updateVal(String code, boolean updateAll) {
        // 结果集
        Result<String> result = new Result<>();
        // 查询库中是有数据
        FundLibrary library = fundLibraryService.getById(ID_PREFIX + code);
        // 判断数据是否为空
        if (library == null) {
            return result.error500("库中没有该基金信息");
        }
        // 生成净值存储表名
        String tableName = tableName(library.getCode());
        // 输入基金代码，获取数据
        JSONObject data = FundDataUtil.getFundValueList(code);
        if (data == null) {
            return result.error500("未爬取到数据");
        }
        // 处理的净值数组
        JSONArray upArr = new JSONArray();
        // 判断是否更新所有数据
        if (!data.getJSONArray("list").isEmpty()) {
            if (updateAll) {
                upArr = data.getJSONArray("list");
            } else {
                JSONArray arr = data.getJSONArray("list");
                // 如果获取到的数值不为空
                if (!arr.isEmpty()) {
                    upArr.add(arr.get(arr.size() - 1));
                }
            }
        }
        // 检查净值表是否存在
        isExistTable(tableName);

        // 更新基金收益率数据
        FundLibrary sylEntity = new FundLibrary()
                .setId(library.getId())
                .setUpdateTime(new Date()) // 防止收益率出现空值，报错
                .setSyl1n(data.getBigDecimal("syl_1n"))
                .setSyl6y(data.getBigDecimal("syl_6y"))
                .setSyl3y(data.getBigDecimal("syl_3y"))
                .setSyl1y(data.getBigDecimal("syl_1y"));
        fundLibraryService.updateById(sylEntity);

        // 遍历处理
        for (Object obj : upArr) {
            // 格式化数据
            JSONObject object = JSONObject.parseObject(obj.toString());
            // 构造净值实体
            FundValue fundVal = new FundValue();
            // 净值日期
            fundVal.setValDate(FundDataUtil.formatDate(object.getString("x")));
            // 设置ID
            fundVal.setId(createId(library.getId(), fundVal.getValDate()));
            // 所属基金
            fundVal.setFundId(library.getId());
            // 单位净值
            fundVal.setNowVal(object.getBigDecimal("y"));
            // 日增长率
            fundVal.setValRate(object.getBigDecimal("equityReturn"));
            // 非估算值
            fundVal.setIsEstimate(0);
            // 更新时间
            fundVal.setUpdateTime(new Date());
            // 创建时间
            fundVal.setCreateTime(new Date());

            // 更新主表数据，设置净值、净值日期、涨幅
            fundLibraryService.updateById(new FundLibrary()
                    .setId(library.getId())
                    .setUpdateTime(new Date())
                    .setNowVal(object.getBigDecimal("y"))
                    .setValDate(FundDataUtil.formatDate(object.getString("x")))
                    .setNowRate(object.getBigDecimal("equityReturn")));
            // 插入或更新
            baseMapper.insertOrUpdate(tableName, fundVal);
            // 生成趋势值
            createLine(fundVal.getValDate(), library.getId(), library.getCode());
        }
        return result;
    }

    @Override
    public void batchUpdateVal(boolean updateAll) {
        log.info("======= 执行净值更新任务 =======");
        log.info("【净值任务】开始时间：" + DateUtil.now());
        // 线程池
        ExecutorService executorService = ExecutorBuilder.create().setCorePoolSize(8).setWorkQueue(new LinkedBlockingQueue<>(200)).build();
        // 查询基金库数据
        List<FundLibrary> list = fundLibraryService.list(new LambdaQueryWrapper<FundLibrary>()
                .ne(FundLibrary::getType, "债券型")
                .ne(FundLibrary::getType, "货币型"));
        // 批次数量
        int batchSize = 200;
        // 批次数组
        List<List<FundLibrary>> batchList = new ArrayList<>();
        // 总数量
        int size = list.size();
        // 遍历获取批次
        for (int i = 0; i < size; i += batchSize) {
            int end = Math.min(i + batchSize, size);
            List<FundLibrary> subList = list.subList(i, end);
            batchList.add(subList);
        }
        // 遍历批次
        for (int i = 0; i < batchList.size(); i++) {
            // 批次获取
            List<FundLibrary> sub = batchList.get(i);
            // 批次号
            final int taskId = i;
            executorService.submit(() -> {
                // log.info("【净值】批次：" + (taskId+1));
                // 数组
                List<FundLibrary> libraryList = new ArrayList<>();
                // 遍历子批次的数据
                for (FundLibrary library : sub) {
                    // 净值列表
                    List<FundValue> valueList = new ArrayList<>();
                    // 生成净值存储表名
                    String tableName = tableName(library.getCode());
                    // 输入基金代码，获取数据
                    JSONObject data = FundDataUtil.getFundValueList(library.getCode());
                    if (data != null) {
                        // 处理的净值数组
                        List<Object> upArr = new ArrayList<>();
                        // 获取数据
                        JSONArray arr = data.getJSONArray("list");
                        // 判断是否更新所有数据
                        if (!arr.isEmpty()) {
                            if (updateAll) {
                                // 仅截取前几个，需优化处理
                                // upArr = arr.subList(arr.size() - 5, arr.size());
                                upArr = arr;
                            } else {
                                upArr.add(arr.get(arr.size() - 1));
                            }
                        }

                        // 检查净值表是否存在
                        isExistTable(tableName);

                        // 更新基金收益率数据
                        FundLibrary sylEntity = new FundLibrary()
                                .setId(library.getId())
                                .setUpdateTime(new Date()) // 防止收益率出现空值，报错
                                .setSyl1n(data.getBigDecimal("syl_1n"))
                                .setSyl6y(data.getBigDecimal("syl_6y"))
                                .setSyl3y(data.getBigDecimal("syl_3y"))
                                .setSyl1y(data.getBigDecimal("syl_1y"));
                        // 遍历处理
                        for (Object obj : upArr) {
                            // 格式化数据
                            JSONObject object = JSONObject.parseObject(obj.toString());
                            // 构造净值实体
                            FundValue fundVal = new FundValue();
                            // 净值日期
                            fundVal.setValDate(FundDataUtil.formatDate(object.getString("x")));
                            // 设置ID
                            fundVal.setId(createId(library.getId(), fundVal.getValDate()));
                            // 所属基金
                            fundVal.setFundId(library.getId());
                            // 单位净值
                            fundVal.setNowVal(object.getBigDecimal("y"));
                            // 日增长率
                            fundVal.setValRate(object.getBigDecimal("equityReturn"));
                            // 非估算值
                            fundVal.setIsEstimate(0);
                            // 更新时间
                            fundVal.setUpdateTime(new Date());
                            // 创建时间
                            fundVal.setCreateTime(new Date());
                            // 插入子表数据
                            valueList.add(fundVal);

                            // 更新主表数据，设置净值、净值日期、涨幅
                            // 获取上日数据
                            BigDecimal lastVal = BigDecimal.ZERO;
                            if (arr.size() >= 2) {
                                // 获取倒数第二条数据
                                Object oj = arr.get(arr.size() - 2);
                                // 格式化处理
                                JSONObject lastJSONObj = JSONObject.parseObject(oj.toString());
                                // 设置上日数据
                                lastVal = lastJSONObj.getBigDecimal("y");
                            }
                            // 设置参数
                            sylEntity
                                    .setId(library.getId())
                                    .setUpdateTime(new Date())
                                    .setLastVal(lastVal)
                                    .setNowVal(object.getBigDecimal("y"))
                                    .setValDate(FundDataUtil.formatDate(object.getString("x")))
                                    .setNowRate(object.getBigDecimal("equityReturn"));
                        }

                        if (!valueList.isEmpty()) {
                            // 更新子表
                            baseMapper.batchInsertOrUpdate(tableName, valueList);
                            // 此处需要判断是更新所有数据，还是单个，获取某表的line60数据
                            List<FundValue> avgList;
                            FundValue value = valueList.get(0);
                            if (updateAll) {
                                // 提取近5个
                                // avgList = baseMapper.findValueAvgList(tableName, library.getId(), String.valueOf(DateUtil.offsetDay(value.getValDate(), -5)), String.valueOf(value.getValDate()));
                                avgList = baseMapper.findValueAvgList(tableName, library.getId(), null, null);
                            } else {
                                avgList = baseMapper.findValueAvgList(tableName, library.getId(), String.valueOf(value.getValDate()), String.valueOf(value.getValDate()));
                            }

                            if (!avgList.isEmpty()) {
                                // 批量更新
                                baseMapper.batchUpdate(tableName, avgList);
                                // 设置主表的估line60
                                sylEntity.setLastLine60(avgList.get(0).getLine60());
                                // 插入数组
                                libraryList.add(sylEntity);
                            }
                        }
                    }
                }
                // 统一更新主表数据
                fundLibraryService.updateBatchById(libraryList);
                if (taskId == batchList.size() - 1) {
                    log.info("【净值任务】结束时间：" + DateUtil.now());
                }
            });
        }
        executorService.shutdown();
    }

    @Override
    public String tableName(String code) {
        // 截取代码后两位
        String name = code.substring(code.length() - 2);
        return TABLE_NAME_PREFIX + name;
    }

    @Override
    public String createId(String fundId, Date date) {
        String dateStr = DateUtil.format(date, "yyyyMMdd");
        return fundId + "-" + dateStr;
    }

    @Override
    public void batchAddAllValue() {
        List<FundLibrary> fundLists = fundLibraryService.list(new LambdaQueryWrapper<FundLibrary>()
                .ne(FundLibrary::getType, "债券型")
                .ne(FundLibrary::getType, "货币型"));
        for (FundLibrary library : fundLists) {
            log.info("开始时间：" + DateUtil.now());
            // 生成净值存储表名
            String tableName = tableName(library.getCode());
            // 检查净值表是否存在
            isExistTable(tableName);
            // 输入基金代码，获取数据
            JSONObject data = FundDataUtil.getFundValueList(library.getCode());
            // 爬取数据不为空
            if (data != null) {
                // 处理的净值数组
                JSONArray upArr = data.getJSONArray("list");

                // 数组
                List<FundValue> fundValueList = new ArrayList<>();
                // 遍历
                for (Object obj : upArr) {
                    // 格式化数据
                    JSONObject object = JSONObject.parseObject(obj.toString());
                    // 构造净值实体
                    FundValue fundVal = new FundValue();
                    // 净值日期
                    fundVal.setValDate(FundDataUtil.formatDate(object.getString("x")));
                    // 设置ID
                    fundVal.setId(createId(library.getId(), fundVal.getValDate()));
                    // 所属基金
                    fundVal.setFundId(library.getId());
                    // 单位净值
                    fundVal.setNowVal(object.getBigDecimal("y"));
                    // 日增长率
                    fundVal.setValRate(object.getBigDecimal("equityReturn"));
                    // 非估算值
                    fundVal.setIsEstimate(0);
                    // 更新时间
                    fundVal.setUpdateTime(new Date());
                    // 创建时间
                    fundVal.setCreateTime(new Date());

                    // 插入到数组
                    fundValueList.add(fundVal);
                }
                // 批量更新
                if (!fundValueList.isEmpty()) {
                    baseMapper.batchInsertOrUpdate(tableName, fundValueList);
                }
                log.info("结束时间：" + DateUtil.now());
            }
        }
    }

    @Override
    public void batchUpdateLine60() {
        List<FundLibrary> fundLibraries = fundLibraryService.list();
        for (FundLibrary library : fundLibraries) {
            log.info("开始时间：" + DateUtil.now());
            // 表名
            String tableName = tableName(library.getCode());
            // 获取所对应的净值
            List<FundValue> valueList = baseMapper.findValueAvgList(tableName, library.getId(), null, null);
            if (!valueList.isEmpty()) {
                // 批量更新
                baseMapper.batchUpdate(tableName, valueList);
                log.info("结束时间：" + DateUtil.now());
            }
        }
    }

    /**
     * 表格是否存在，如果不存在则建表格
     *
     * @param tableName 表名
     */
    public void isExistTable(String tableName) {
        // 判断净值表是否存在
        int isExist = baseMapper.isExistTable(tableName);
        // 表不存在，则新建
        if (isExist == 0) {
            baseMapper.createTable(tableName);
        }
    }

    /**
     * 生成基准值
     *
     * @param date   当日日期
     * @param fundId 基金主键
     */
    public void createLine(Date date, String fundId, String code) {
        try {
            // 表名
            String tableName = tableName(code);
            // 查询净值数据
            FundValue val = baseMapper.findById(tableName, createId(fundId, date));
            if (val == null) {
                return;
            }
            // 查询数据：近60天净值统计
            // 起始日期
            String startDate = DateUtil.format(date, "yyyy-MM-dd");
            // 结束日期
            String endDate = DateUtil.format(DateUtil.offsetDay(date, -59), "yyyy-MM-dd");
            // 获取总计值
            FundValTotalModel map = baseMapper.get60ValTotal(tableName, fundId, startDate, endDate);
            // 数据不为空
            if (map != null) {
                // 获取净值合并总值
                BigDecimal totalVal = map.getTotalVal();
                // 计算趋势值
                BigDecimal mo = totalVal.divide(new BigDecimal(map.getCount()), RoundingMode.FLOOR);
                // 更新子表
                baseMapper.insertOrUpdate(tableName,
                        new FundValue()
                                .setId(val.getId())
                                .setLine60(mo));
                // 更新主表
                fundLibraryService.updateById(new FundLibrary().setId(fundId).setLastLine60(mo));
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void updateEstimate() {
        // 核心线程数（建议CPU核心数*2~5）
        try {
            ExecutorService executorService = ExecutorBuilder.create().setCorePoolSize(5).setWorkQueue(new LinkedBlockingQueue<>(200)).build();
            log.info("==============执行估值更新任务============");
            log.info("【估值任务】开始时间：" + DateUtil.now());
            // 根据规则获取代码
            List<FundLibrary> codeList = fundLibraryService.list(new QueryWrapper<FundLibrary>()
                    .select("RIGHT(code,2) as 'code'")
                    .groupBy("RIGHT(code,2)"));

            for (int i = 0; i < codeList.size(); i++) {
                // 批次号
                final int taskId = i;
                // 分类代码
                String categoryCode = codeList.get(i).getCode();
                // 根据code获取分类的基金列表
                List<FundLibrary> fundLibraryList = fundLibraryService.list(new QueryWrapper<FundLibrary>()
                        .ne("type", "货币型")
                        .eq("RIGHT(code,2)", categoryCode));
                // 表名
                String tableName = TABLE_NAME_PREFIX + categoryCode;
                // 线程池
                executorService.submit(() -> {
                    // 子表数组
                    List<FundValue> subList = new ArrayList<>();
                    // 遍历子批次
                    for (FundLibrary library : fundLibraryList) {
                        // 如果是QDII则跳过
                        if ("QDII".equals(library.getType())) {
                            continue;
                        }
                        // 请求接口获取估值
                        JSONObject object = FundDataUtil.getEstimateVal(library.getCode());
                        // 如果没有估算数据，就跳过、QDII没有估值
                        if (object != null) {
                            // ******* 构造子表实体 *********
                            // 日期，注意存在空的情况
                            String date = object.getString("gztime");
                            // FundId
                            String fundId = library.getId();
                            // 子表ID
                            String valId = this.createId(fundId, DateUtil.parseDate(date));
                            // 查询净值
                            FundValue value = baseMapper.findById(tableName, valId);
                            // 空值或者估值，不更新
                            if (date != null && (value == null || value.getIsEstimate() == 1)) {
                                // 实体构造
                                FundValue valueEntity = new FundValue();
                                // 设置主键
                                valueEntity.setId(valId);
                                // 净值日期
                                valueEntity.setValDate(DateUtil.parseDate(date));
                                // 所属基金ID
                                valueEntity.setFundId(fundId);
                                // 单位净值
                                valueEntity.setNowVal(object.getBigDecimal("gsz"));
                                // 日增长率
                                valueEntity.setValRate(object.getBigDecimal("gszzl"));
                                // 设置状态为估算状态
                                valueEntity.setIsEstimate(1);
                                // 设置创建时间
                                valueEntity.setCreateTime(new Date());
                                // 设置更新时间
                                valueEntity.setUpdateTime(new Date());
                                // 插入子表数组
                                subList.add(valueEntity);
                            }
                        }
                    }

                    if (!subList.isEmpty()) {
                        // 日期
                        String date = DateUtil.format(subList.get(0).getValDate(), "yyyy-MM-dd");
                        // 更新子表，上面已经有限制如果是净值，不更新
                        baseMapper.batchInsertOrUpdate(tableName, subList);
                        // 获取line60
                        List<FundValue> avgList = baseMapper.findValueAvgByDate(tableName, date);
                        // 更新子表的line60
                        baseMapper.batchInsertOrUpdate(tableName, avgList);
                        // 更新主表的估值及line60
                        fundLibraryMapper.updateEstimateLine60(avgList);
                        // log.info("单个批次执行完毕");
                        if (taskId == codeList.size() - 1) {
                            log.info("【估值任务】结束时间：" + DateUtil.now());
                        }
                    }
                });
            }
            executorService.shutdown();
        } catch (Exception e) {
            log.info("估值同步出现异常");
            log.error(e.getMessage());
        }
    }

    @Override
    public void batchUpdateThsValue() {
        // 线程池
        ExecutorService executorService = ExecutorBuilder.create().setCorePoolSize(4).setWorkQueue(new LinkedBlockingQueue<>(100)).build();
        // 根据规则获取代码
        List<FundLibrary> categroyList = fundLibraryService.list(new QueryWrapper<FundLibrary>()
                .select("RIGHT(code,2) as 'code'")
                .groupBy("RIGHT(code,2)"));
        // 遍历类别
        for (FundLibrary fundLibrary : categroyList) {
            // 分类代码
            String categoryCode = fundLibrary.getCode();
            // 根据code获取分类的基金列表
            List<FundLibrary> list = fundLibraryService.list(new QueryWrapper<FundLibrary>().eq("RIGHT(code,2)", categoryCode));
            // 表名
            String tableName = TABLE_NAME_PREFIX + categoryCode;
            // 线程池
            executorService.submit(() -> {
                for (FundLibrary library : list) {
                    // 检查净值表是否存在
                    isExistTable(tableName);
                    // 输入基金代码，获取数据
                    JSONArray dataList = TonghsDataUtil.requestData(library.getCode());
                    // 爬取数据不为空
                    if (dataList != null) {
                        // 数组
                        List<FundValue> fundValueList = new ArrayList<>();
                        // 遍历
                        try {
                            for (int t = 0; t < dataList.size(); t++) {
                                JSONArray object = dataList.getJSONArray(t);
                                // 构造净值实体
                                FundValue fundVal = new FundValue();
                                // 净值日期
                                fundVal.setValDate(object.getDate(0));
                                // 设置ID
                                fundVal.setId(createId(library.getId(), fundVal.getValDate()));
                                // 所属基金
                                fundVal.setFundId(library.getId());
                                // 单位净值
                                fundVal.setNowVal(object.getBigDecimal(1));
                                // 日增长率
                                if (t == 0) {
                                    fundVal.setValRate(BigDecimal.ZERO);
                                } else {
                                    // 获取上个值
                                    JSONArray lastData = dataList.getJSONArray(t - 1);
                                    // 计算增长率,必须设置小数点精度，否则会因除法出现无限循环小数，而导致死循环
                                    BigDecimal rate = (object.getBigDecimal(1).subtract(lastData.getBigDecimal(1))).divide(lastData.getBigDecimal(1), 6, RoundingMode.HALF_UP);
                                    // 设置增长率
                                    fundVal.setValRate(rate.multiply(new BigDecimal("100")));
                                }
                                // 非估算值
                                fundVal.setIsEstimate(0);
                                // 更新时间
                                fundVal.setUpdateTime(new Date());
                                // 创建时间
                                fundVal.setCreateTime(new Date());

                                // 插入到数组
                                fundValueList.add(fundVal);
                            }
                            // 批量更新
                            if (!fundValueList.isEmpty()) {
                                // 批量更新数据
                                baseMapper.batchInsertOrUpdate(tableName, fundValueList);
                                // 获取所对应的净值
                                List<FundValue> valueList = baseMapper.findValueAvgList(tableName, library.getId(), null, null);
                                if (!valueList.isEmpty()) {
                                    // 批量更新line60
                                    baseMapper.batchUpdate(tableName, valueList);
                                }
                            }
                        } catch (Exception e) {
                            log.error("同步异常");
                        }
                    }
                }
            });
        }
    }

    @Override
    public void batchUpdateAddCount() {
        // 线程池
        ExecutorService executorService = ExecutorBuilder.create().setCorePoolSize(4).setWorkQueue(new LinkedBlockingQueue<>(100)).build();
        try {
            log.info("开始处理加仓次数");
            // 根据规则获取代码
            List<FundLibrary> categroyList = fundLibraryService.list(new QueryWrapper<FundLibrary>()
                    .select("RIGHT(code,2) as 'code'")
                    .groupBy("RIGHT(code,2)"));
            // 遍历类别
            for (FundLibrary fundLibrary : categroyList) {
                // 分类代码
                String categoryCode = fundLibrary.getCode();
                // 表名
                String tableName = TABLE_NAME_PREFIX + categoryCode;
                // 根据code获取分类的基金列表
                List<FundLibrary> list = fundLibraryService.list(new QueryWrapper<FundLibrary>()
                        .eq("RIGHT(code,2)", categoryCode)
                        .isNotNull("val_date")
                        .isNotNull("estimate_val_date")
                        .isNotNull("last_line_60")
                        .isNotNull("now_val"));
                // 线程池
                executorService.submit(() -> {
                    // 参数
                    List<FundLibrary> libraryListParams = new ArrayList<>();
                    // 遍历数据
                    for (FundLibrary library : list) {
                        if(library.getAddCountDate() != null && library.getValDate().compareTo(library.getAddCountDate()) == 0){
                            continue;
                        }
                        // 加仓临时值
                        BigDecimal tempVal = library.getLastLine60().multiply(library.getDefaultAddVal());
                        // 净值 <= 曲线值
                        if (library.getNowVal().compareTo(tempVal) <= 0) {
                            // 满足加仓条件
                            String endDate = DateUtil.format(library.getValDate(), "yyyy-MM-dd");
                            String startDate = DateUtil.format(DateUtil.offsetDay(new Date(), -80), "yyyy-MM-dd");
                            List<FundValue> valueList = baseMapper.findList(tableName, library.getId(), startDate, endDate);
                            // 倒序
                            Collections.reverse(valueList);
                            int total = 0;
                            for (FundValue value : valueList) {
                                BigDecimal addTemp = value.getLine60().multiply(library.getDefaultAddVal());
                                if (value.getNowVal().compareTo(addTemp) <= 0) {
                                    total += 1;
                                    // 数量赋值
                                    library.setAddCount(total);
                                } else {
                                    BigDecimal reduceTemp = value.getLine60().multiply(library.getDefaultReduceVal());
                                    if (value.getNowVal().compareTo(reduceTemp) >= 0) {
                                        break;
                                    }
                                }
                            }
                        } else {
                            // 需要判断是否满足减仓条件
                            // 减仓临时值
                            BigDecimal tempReduceVal = library.getLastLine60().multiply(library.getDefaultReduceVal());
                            // 净值 >= 曲线值
                            if (library.getNowVal().compareTo(tempReduceVal) >= 0) {
                                library.setAddCount(0);
                            }
                        }
                        // 设置净值更新日期
                        library.setAddCountDate(library.getValDate());
                        // 添加参数
                        libraryListParams.add(new FundLibrary().setId(library.getId()).setAddCount(library.getAddCount()).setAddCountDate(library.getAddCountDate()));
                    }
                    if (!libraryListParams.isEmpty()) {
                        log.info("更新数据");
                        // 批量更新数据
                        fundLibraryService.updateBatchById(libraryListParams);
                    }
                });
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            executorService.shutdown();
            log.info("结束更新加仓次数");
        }
    }
}
